\documentclass[a4paper]{article}

\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}

\title{Compilateur}
\author{DeHaro Léonard, Lacroix Timothée}

\begin{document}
\maketitle

\renewcommand{\t}{\hspace{10pt}}

\section*{Simulateur}
Nous devions être capable de simuler une net-list écrit dans notre langage. Nous avons décidé d'ajouter une étape de compilation, produisant un fichier texte dont la simulation est très simple.
Le format de fichier, ainsi que le fonctionnement

\subsection*{Fichier .cir}
\paragraph{Première ligne :}
\texttt{[nombre de variables]}
\paragraph{Lignes suivantes :}
Chaque ligne déclare une variable \\
\texttt{[fonction] [argument 1] [argument 2] [type d'affichage] [nom]}

\paragraph{[fonction] :} Decrit la fonction a appliquer sur arg1 et arg2 pour obtenir la valeur de la variable. \\
1 = true \t 0 = false \t X = xor \t A = and \t N = not \t O = or \t R = registre \t I = variable d'entrée

\paragraph{[argument 1] et [argument 2] :} Font réference aux numeros des variables en argument de [fonction]. Les numéros sont atribués dans l'ordre de declaration dans le fichier en commençant par 0. Pour les fonctions a un seul argument, on utilise [argument 1].

\paragraph{[type d'affichage] :} Dit quand afficher la variable. \\
T = a chaque tour \t D = a la fin \t N = jamais

\paragraph{[nom] :} Donne un nom a la variable lors de son affichage. Le nom est obligatoire si [type d'affichage] = T ou D et doit etre vide sinon

\subsection*{Fichier .in}
\paragraph{Première ligne :}
\texttt{[nombre de variables] [nombre d'états]}
\paragraph{Lignes suivantes :}
Chaque ligne définit les états successifs de la variable d'entrée correspondant à cette ligne. La variable décrite par la i-ème ligne correspondra au i-ème I du fichier .cir.

\subsection*{Simulateur}
Simuler le fichier .cir ne présente aucune subtilité. On calcul le nouvel état en lisant le fichier .cir lignes par lignes, les opérations étant décrites dans le bon ordre. Pour les registres, il faut un buffer pour 
effectuer le décalage.\\
Le simulateur est codé en C++, on utilise la librairie Qt pour produire une interface graphique agréable, qui permet de simuler pas par pas, avec affichage des variables d'entrées et de sorties, le tout a fréquence variable.

\section*{Compilateur}
Le processus de compilation s'effectue en plusieurs étapes. On commence par créer un AST qu'on tranforme ensuite en graphe. L'idée est qu'en dessinant ce graphe, on doit retomber exactement sur le circuit duquel on est parti. 
Un noeud dans ce graphe correspond à une valeur, une transition représente une piste sur le circuit. Les erreurs de syntaxe sont detectées, mais ne donnent pas lieux à un traitement complexe. Nous avons voulu garder le code du 
compilateur le plus simple possible, puisque c'est sa correction qui conditionne celle du fichier .cir produit.
\subsection*{Blocs}
Une fonction est représentée par un bloc. Un bloc est défini par son graphe, qui comporte des noeuds IN et une liste de noeuds de sortie. L'appel d'un bloc se fait lors d'une affectation, et consiste a créer une nouvelle instance 
du bloc (en ajoutant son graphe à celui du bloc dans lequel il est appelé), puis à brancher les valeurs des arguments sur les noeuds IN, et associer dans une map les noms des variables affectées et les identifiants des noeuds correspondant.
\subsection*{Modification du graphe}
Le graphe ainsi produit est trop gros, pleins de noeuds IN intermédiaire sont créés. Un parcours du graphe permet de les détécter et de les supprimer. De même, les noeuds TRUE et FALSE sont répétés, ce qui n'est pas nécessaire. Pour 
l'instant, l'optimisation consistant à créer deux noeuds TRUE et FALSE et à les relier où il faut n'est pas implémentée. On effectue ensuite un tri topologique sur le graphe, qui nous permet de trouver l'ordre dans lequel chacun des
 noeuds sera écrit dans le fichier .cir.


\section*{Ajout d'option utiles}
Il est apparu utile pour la suite de permettre les fils et les boucles for.

\subsection*{Gros fils}
Nous avons choisis de représenter les fils la syntaxes suivantes \texttt{$n$nomdufil}. Par exemple: \texttt{32a} représente un fil contenant 32 variables.
La reconnaissance de cette syntaxe a nécessitée une nouvelle règle dans le lexer pour reconnaître
 la particularité de ces "variables". Une fois reconnu le fil grâce au préfixe entier représentant sa taille nous générons toutes les variables \texttt{$n$fils[$i$]} pour $i$ variant de $0$ à $n-1$. On peut ainsi accéder à la 3ème variable du fil \texttt{32a} à l'aide de la syntaxe \texttt{32a[3]}.

\subsection*{Boucle for}
La syntaxe de la boucle \textit{for} est la suivant:\\
\texttt{ for (k,$d$,$a$)\\
\{\\
...\\
\}\\
}
où  $d$ est l'entier (une valeur!) de départ du compteur et $a$ la borne supérieurs (pas de compteur décroissant pour l'instant) et la partie entre accolades est une suite d'affectations. Lorsque le parser rencontre une boucle \textit{for}, il génère une liste d'affectations en réécrivant chaque affectation autant de fois que nécessaire en remplaćant à chaque fois les valeur de \texttt{k} par sa valeur. On notera que les boucles \textit{for} ne permettent de faire varier le compteur que dans les indices des gros fils ("entre crochets") et que pour l'instant elles n'autorisent pas d'opérations arithmétiques sur les compteurs (mais nous y travaillons).
Un exemple d'utilisation serait:\\
\texttt{ for (k,$0$,$4$)\\
\{\\
5fils[k]=$0$\\
\}\\
}


\end{document}